Otimização de DataFrame Pandas: Uso de Memória e Ajuste de Desempenho

Pandas é uma poderosa biblioteca Python para manipulação e análise de dados. No entanto, ao trabalhar com grandes conjuntos de dados, os DataFrames do Pandas podem consumir uma quantidade significativa de memória e apresentar baixo desempenho. Este artigo fornece um guia completo para otimizar DataFrames Pandas tanto para o uso de memória quanto para o desempenho, permitindo que você processe conjuntos de dados maiores de forma mais eficiente.

Entendendo o Uso de Memória em DataFrames Pandas

Antes de mergulhar nas técnicas de otimização, é crucial entender como os DataFrames Pandas armazenam dados na memória. Cada coluna em um DataFrame possui um tipo de dado específico, que determina a quantidade de memória necessária para armazenar seus valores. Os tipos de dados comuns incluem:

• int64: Inteiros de 64 bits (padrão para inteiros)
• float64: Números de ponto flutuante de 64 bits (padrão para números de ponto flutuante)
• object: Objetos Python (usado para strings e tipos de dados mistos)
• category: Dados categóricos (eficiente para valores repetitivos)
• bool: Valores booleanos (True/False)
• datetime64: Valores de data e hora

O tipo de dado object é frequentemente o que mais consome memória porque armazena ponteiros para objetos Python, que podem ser significativamente maiores que tipos de dados primitivos como inteiros ou floats. Strings, mesmo as curtas, quando armazenadas como `object`, consomem muito mais memória do que o necessário. Da mesma forma, usar `int64` quando `int32` seria suficiente desperdiça memória.

Exemplo: Inspecionando o Uso de Memória do DataFrame

Você pode usar o método memory_usage() para inspecionar o uso de memória de um DataFrame:

            import pandas as pd
import numpy as np

data = {
    'col1': np.random.randint(0, 1000, 100000),
    'col2': np.random.rand(100000),
    'col3': ['A', 'B', 'C'] * (100000 // 3 + 1)[:100000],
    'col4': ['This is a long string'] * 100000
}

df = pd.DataFrame(data)

memory_usage = df.memory_usage(deep=True)
print(memory_usage)
print(df.dtypes)

            

              
                Copy
              
            
          

O argumento deep=True garante que o uso de memória de objetos (como strings) seja calculado com precisão. Sem deep=True, ele calculará apenas a memória para os ponteiros, não para os dados subjacentes.

Otimizando Tipos de Dados

Uma das maneiras mais eficazes de reduzir o uso de memória é escolher os tipos de dados mais apropriados para as colunas do seu DataFrame. Aqui estão algumas técnicas comuns:

1. Downcasting de Tipos de Dados Numéricos

Se suas colunas de inteiros ou de ponto flutuante não exigem toda a faixa de precisão de 64 bits, você pode fazer o downcast delas para tipos de dados menores como int32, int16, float32 ou float16. Isso pode reduzir significativamente o uso de memória, especialmente para grandes conjuntos de dados.

Exemplo: Considere uma coluna que representa a idade, que provavelmente não excederá 120. Armazenar isso como `int64` é um desperdício; `int8` (intervalo de -128 a 127) seria mais apropriado.

            def downcast_numeric(df):
    """Faz o downcast de colunas numéricas para o menor tipo de dado possível."""
    for col in df.columns:
        if pd.api.types.is_integer_dtype(df[col]):
            df[col] = pd.to_numeric(df[col], downcast='integer')
        elif pd.api.types.is_float_dtype(df[col]):
            df[col] = pd.to_numeric(df[col], downcast='float')
    return df

df = downcast_numeric(df.copy())
print(df.memory_usage(deep=True))
print(df.dtypes)

            

              
                Copy
              
            
          

A função pd.to_numeric() com o argumento downcast é usada para selecionar automaticamente o menor tipo de dado possível que pode representar os valores na coluna. O copy() evita modificar o DataFrame original. Sempre verifique o intervalo de valores em seus dados antes de fazer o downcast para garantir que você não perca informações.

2. Usando Tipos de Dados Categóricos

Se uma coluna contém um número limitado de valores únicos, você pode convertê-la para o tipo de dado category. Tipos de dados categóricos armazenam cada valor único apenas uma vez e, em seguida, usam códigos inteiros para representar os valores na coluna. Isso pode reduzir significativamente o uso de memória, especialmente para colunas com uma alta proporção de valores repetidos.

Exemplo: Considere uma coluna representando códigos de países. Se você está lidando com um conjunto limitado de países (por exemplo, apenas países da União Europeia), armazenar isso como uma categoria será muito mais eficiente do que armazenar como strings.

            def optimize_categories(df):
    """Converte colunas do tipo object com baixa cardinalidade para o tipo categórico."""
    for col in df.columns:
        if df[col].dtype == 'object':
            num_unique_values = len(df[col].unique())
            num_total_values = len(df[col])
            if num_unique_values / num_total_values < 0.5:
                df[col] = df[col].astype('category')
    return df

df = optimize_categories(df.copy())
print(df.memory_usage(deep=True))
print(df.dtypes)

            

              
                Copy
              
            
          

Este código verifica se o número de valores únicos em uma coluna do tipo object é menor que 50% do total de valores. Se for, ele converte a coluna para um tipo de dado categórico. O limiar de 50% é arbitrário e pode ser ajustado com base nas características específicas dos seus dados. Essa abordagem é mais benéfica quando a coluna contém muitos valores repetidos.

3. Evitando Tipos de Dados Object para Strings

Como mencionado anteriormente, o tipo de dado object é frequentemente o que mais consome memória, especialmente quando usado para armazenar strings. Se possível, tente evitar o uso de tipos de dados object para colunas de string. Tipos categóricos são preferíveis para strings com baixa cardinalidade. Se a cardinalidade for alta, considere se as strings podem ser representadas com códigos numéricos ou se os dados de string podem ser evitados completamente.

Se você precisar realizar operações de string na coluna, talvez precise mantê-la como um tipo object, mas considere se essas operações podem ser realizadas antecipadamente e, em seguida, convertidas para um tipo mais eficiente.

4. Dados de Data e Hora

Use o tipo de dado `datetime64` para informações de data e hora. Garanta que a resolução seja apropriada (resolução em nanossegundos pode ser desnecessária). O Pandas lida com dados de séries temporais de forma muito eficiente.

Otimizando Operações do DataFrame

Além de otimizar os tipos de dados, você também pode melhorar o desempenho dos DataFrames Pandas otimizando as operações que realiza neles. Aqui estão algumas técnicas comuns:

1. Vetorização

Vetorização é o processo de realizar operações em arrays ou colunas inteiras de uma só vez, em vez de iterar sobre elementos individuais. O Pandas é altamente otimizado para operações vetorizadas, portanto, usá-las pode melhorar significativamente o desempenho. Evite laços explícitos sempre que possível. As funções integradas do Pandas são geralmente muito mais rápidas do que os laços Python equivalentes.

Exemplo: Em vez de iterar através de uma coluna para calcular o quadrado de cada valor, use a função pow():

            # Ineficiente (usando um laço)
import time

start_time = time.time()
results = []
for value in df['col2']:
    results.append(value ** 2)
df['col2_squared_loop'] = results
end_time = time.time()
print(f"Tempo do laço: {end_time - start_time:.4f} segundos")

# Eficiente (usando vetorização)
start_time = time.time()
df['col2_squared_vectorized'] = df['col2'] ** 2
end_time = time.time()
print(f"Tempo vetorizado: {end_time - start_time:.4f} segundos")


            

              
                Copy
              
            
          

A abordagem vetorizada é tipicamente ordens de magnitude mais rápida do que a abordagem baseada em laços.

2. Usando `apply()` com Cuidado

O método apply() permite que você aplique uma função a cada linha ou coluna de um DataFrame. No entanto, é geralmente mais lento do que operações vetorizadas porque envolve a chamada de uma função Python para cada elemento. Use apply() apenas quando operações vetorizadas não forem possíveis.

Se você precisar usar `apply()`, tente vetorizar a função que está aplicando o máximo possível. Considere usar o decorador `jit` do Numba para compilar a função para código de máquina para melhorias significativas de desempenho.

            from numba import jit

@jit(nopython=True)
def my_function(x):
    return x * 2  # Função de exemplo

df['col2_applied'] = df['col2'].apply(my_function)

            

              
                Copy
              
            
          

3. Selecionando Colunas de Forma Eficiente

Ao selecionar um subconjunto de colunas de um DataFrame, use os seguintes métodos para um desempenho ideal:

• Seleção direta de coluna: df[['col1', 'col2']] (mais rápido para selecionar algumas colunas)
• Indexação booleana: df.loc[:, [True if col.startswith('col') else False for col in df.columns]] (útil para selecionar colunas com base em uma condição)

Evite usar df.filter() com expressões regulares para selecionar colunas, pois pode ser mais lento do que outros métodos.

4. Otimizando Joins e Merges

Juntar e mesclar DataFrames pode ser computacionalmente caro, especialmente para grandes conjuntos de dados. Aqui estão algumas dicas para otimizar joins e merges:

• Use chaves de junção apropriadas: Garanta que as chaves de junção tenham o mesmo tipo de dado e estejam indexadas.
• Especifique o tipo de join: Use o tipo de join apropriado (por exemplo, inner, left, right, outer) com base em seus requisitos. Um inner join é geralmente mais rápido que um outer join.
• Use `merge()` em vez de `join()`: A função merge() é mais versátil e frequentemente mais rápida que o método join().

Exemplo:

            df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value1': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'], 'value2': [5, 6, 7, 8]})

# Inner join eficiente
df_merged = pd.merge(df1, df2, on='key', how='inner')

print(df_merged)

            

              
                Copy
              
            
          

5. Evitando Copiar DataFrames Desnecessariamente

Muitas operações do Pandas criam cópias de DataFrames, o que pode consumir muita memória e tempo. Para evitar cópias desnecessárias, use o argumento inplace=True quando disponível, ou atribua o resultado de uma operação de volta ao DataFrame original. Tenha muito cuidado com inplace=True, pois pode mascarar erros e dificultar a depuração. Geralmente é mais seguro reatribuir, mesmo que seja um pouco menos performático.

Exemplo:

            # Ineficiente (cria uma cópia)
df_filtered = df[df['col1'] > 500]

# Eficiente (modifica o DataFrame original no local - CUIDADO)
df.drop(df[df['col1'] <= 500].index, inplace=True)

# MAIS SEGURO - reatribui, evita o inplace
df = df[df['col1'] > 500]

            

              
                Copy
              
            
          

6. Processamento em Lotes (Chunking) e Iteração

Para conjuntos de dados extremamente grandes que não cabem na memória, considere processar os dados em lotes (chunks). Use o parâmetro `chunksize` ao ler dados de arquivos. Itere através dos lotes e realize sua análise em cada lote separadamente. Isso requer um planejamento cuidadoso para garantir que a análise permaneça correta, pois algumas operações exigem o processamento de todo o conjunto de dados de uma vez.

            # Lê o CSV em lotes
for chunk in pd.read_csv('large_data.csv', chunksize=100000):
    # Processa cada lote
    print(chunk.shape)

            

              
                Copy
              
            
          

7. Usando Dask para Processamento Paralelo

Dask é uma biblioteca de computação paralela que se integra perfeitamente com o Pandas. Ele permite processar grandes DataFrames em paralelo, o que pode melhorar significativamente o desempenho. O Dask divide o DataFrame em partições menores e as distribui por vários núcleos ou máquinas.

            import dask.dataframe as dd

# Cria um DataFrame Dask
ddf = dd.read_csv('large_data.csv')

# Realiza operações no DataFrame Dask
ddf_filtered = ddf[ddf['col1'] > 500]

# Computa o resultado (isso aciona a computação paralela)
result = ddf_filtered.compute()

print(result.head())

            

              
                Copy
              
            
          

Indexação para Buscas Mais Rápidas

Criar um índice em uma coluna pode acelerar significativamente as operações de busca e filtragem. O Pandas usa índices para localizar rapidamente linhas que correspondem a um valor específico.

Exemplo:

            # Define 'col3' como o índice
df = df.set_index('col3')

# Busca mais rápida
value = df.loc['A']

print(value)

# Reseta o índice
df = df.reset_index()

            

              
                Copy
              
            
          

No entanto, criar muitos índices pode aumentar o uso de memória e retardar as operações de escrita. Crie índices apenas em colunas que são frequentemente usadas para buscas ou filtragem.

Outras Considerações

• Hardware: Considere atualizar seu hardware (CPU, RAM, SSD) se você trabalha consistentemente com grandes conjuntos de dados.
• Software: Certifique-se de que está usando a versão mais recente do Pandas, pois versões mais novas frequentemente incluem melhorias de desempenho.
• Profiling (Análise de Desempenho): Use ferramentas de profiling (por exemplo, cProfile, line_profiler) para identificar gargalos de desempenho em seu código.
• Formato de Armazenamento de Dados: Considere usar formatos de armazenamento de dados mais eficientes como Parquet ou Feather em vez de CSV. Esses formatos são colunares e frequentemente compactados, resultando em arquivos menores e tempos de leitura/escrita mais rápidos.

Conclusão

Otimizar DataFrames Pandas para uso de memória e desempenho é crucial para trabalhar com grandes conjuntos de dados de forma eficiente. Ao escolher os tipos de dados apropriados, usar operações vetorizadas e indexar seus dados de forma eficaz, você pode reduzir significativamente o consumo de memória e melhorar o desempenho. Lembre-se de analisar o desempenho do seu código para identificar gargalos e considere usar processamento em lotes ou Dask para conjuntos de dados extremamente grandes. Ao implementar essas técnicas, você pode desbloquear todo o potencial do Pandas para análise e manipulação de dados.